home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1997 January: Mac OS SDK / Dev.CD Jan 97 SDK2.toast / Development Kits (Disc 2) / OpenDoc Development Framework / ODFDev / ODF / Framewrk / FWSemEvt / FWSemInt.cpp < prev    next >
Encoding:
Text File  |  1996-09-17  |  22.8 KB  |  708 lines  |  [TEXT/MPS ]
  1. //========================================================================================
  2. //
  3. //    File:                FWSemInt.cpp
  4. //    Release Version:    $ ODF 2 $
  5. //
  6. //    Copyright:    (c) 1993 - 1996 by Apple Computer, Inc., all rights reserved.
  7. //
  8. //========================================================================================
  9.  
  10. #ifndef FWSEMINT_H
  11. #include "FWSemInt.h"
  12. #endif
  13.  
  14. // ----- Framework Includes -----
  15.  
  16. #ifndef FWACQSCR_H
  17. #include "FWAcqScr.h"
  18. #endif
  19.  
  20. #ifndef FWEXTMGR_H
  21. #include "FWExtMgr.h"
  22. #endif
  23.  
  24. #ifndef FWPART_H
  25. #include "FWPart.h"
  26. #endif
  27.  
  28. #ifndef PRSIGLUE_H
  29. #include "PRSIGlue.h"
  30. #endif
  31.  
  32. #ifndef FWAPLEVT_H
  33. #include "FWAplEvt.h"
  34. #endif
  35.  
  36. #ifndef FWDSCOPR_H
  37. #include "FWDscOpr.h"
  38. #endif
  39.  
  40. #ifndef FWSCPCAL_H
  41. #include "FWScpCal.h"
  42. #endif
  43.  
  44. #ifndef FWSCPCOL_H
  45. #include "FWScpCol.h"
  46. #endif
  47.  
  48. #ifndef FWSCPTBL_H
  49. #include "FWScptbl.h"
  50. #endif
  51.  
  52. #ifndef FWPRTSCP_H
  53. #include "FWPrtScp.h"
  54. #endif
  55.  
  56. #ifndef FWSCPPRP_H
  57. #include "FWScpPrp.h"
  58. #endif
  59.  
  60. #ifndef FWITERS_H
  61. #include "FWIters.h"
  62. #endif
  63.  
  64. #ifndef FWCONTXT_H
  65. #include "FWContxt.h"
  66. #endif
  67.  
  68. #ifndef FWEVENTU_H
  69. #include "FWEventU.h"
  70. #endif
  71.  
  72. #ifndef FWINK_H
  73. #include "FWInk.h"
  74. #endif
  75.  
  76. #ifndef FWOVLSHP_H
  77. #include "FWOvlShp.h"
  78. #endif
  79.  
  80. #ifndef SOM_FW_OSemanticInterface_xh
  81. #include "SLSemInt.xh"
  82. #endif
  83.  
  84. #ifndef FWSOMENV_H
  85. #include "FWSOMEnv.h"
  86. #endif
  87.  
  88. #ifndef FWSESION_H
  89. #include "FWSesion.h"
  90. #endif
  91.  
  92. // ----- OpenDoc Includes -----
  93.  
  94. #ifndef SOM_Module_OpenDoc_StandardExtensions_defined
  95. #include <StdExts.xh>
  96. #endif
  97.  
  98. #ifndef SOM_Module_OpenDoc_ODRegistry_defined
  99. #include <ODRgstry.xh>
  100. #endif
  101.  
  102. #ifndef SOM_ODNameResolver_xh
  103. #include <NamRslvr.xh>
  104. #endif
  105.  
  106. #ifndef SOM_ODObjectSpec_xh
  107. #include <ODObjSpc.xh>
  108. #endif
  109.  
  110. #ifndef SOM_ODOSLToken_xh
  111. #include <ODOSLTkn.xh>
  112. #endif
  113.  
  114. // ----- Macintosh Includes -----
  115.  
  116. #ifndef __ASREGISTRY__
  117. #include <ASRegistry.h>
  118. #endif
  119.  
  120. //========================================================================================
  121. //    Runtime Information
  122. //========================================================================================
  123.  
  124. #ifdef FW_BUILD_MAC    
  125. #pragma segment fwsemevt
  126. #endif
  127.  
  128. FW_DEFINE_AUTO(FW_CSemanticInterface)
  129.  
  130. //========================================================================================
  131. //    class FW_CSemanticInterface
  132. //========================================================================================
  133.  
  134. //---------------------------------------------------------------------------------------
  135. //    FW_CSemanticInterface::FW_CSemanticInterface
  136. //---------------------------------------------------------------------------------------
  137.  
  138. FW_CSemanticInterface::FW_CSemanticInterface(Environment* ev, FW_CPart* part) :
  139.     fDefaultContainer(FW_DYNAMIC_CAST(FW_MPartScriptable, part)),
  140.     fPart(part),
  141.     fOSLFlags(kAEIDoMinimum),
  142.     fUsingPredispatchProc(FALSE)
  143. {
  144. FW_UNUSED(ev);
  145.  
  146.     FW_END_CONSTRUCTOR
  147.     
  148.     // OpenDoc releases 1.0 - 1.04 (possibly later) have a bug that prevents marking 
  149.     // from working correctly. The bug causes OpenDoc to look at the OSL flags of 
  150.     // the part's containing part when determining whether or not a part marks. This 
  151.     // means that if a part says it does marking, OpenDoc will treat it as if it does 
  152.     // not, but will treat all parts contained by that part as if they do.
  153. }
  154.  
  155. //---------------------------------------------------------------------------------------
  156. //    FW_CSemanticInterface::~FW_CSemanticInterface
  157. //---------------------------------------------------------------------------------------
  158.  
  159. FW_CSemanticInterface::~FW_CSemanticInterface()
  160. {
  161.     FW_START_DESTRUCTOR
  162. }
  163.                                                     
  164. //---------------------------------------------------------------------------------------
  165. //    FW_CSemanticInterface::CreateSOMInterface
  166. //---------------------------------------------------------------------------------------
  167.  
  168. FW_OSemanticInterface* FW_CSemanticInterface::CreateSOMInterface(Environment *ev, 
  169.                                                                 FW_CPart *part, 
  170.                                                                 const char *name,
  171.                                                                 void* refCon)
  172. {    
  173. FW_UNUSED(name);
  174. FW_UNUSED(refCon);
  175.     FW_OSemanticInterface* semInt = new FW_OSemanticInterface;
  176.     semInt->InitODFSemanticInterface(ev, part->GetODPart(ev), FW_CSession::GetODSession(ev), this,  FW_PrivGetSemanticInterfaceGlue());
  177.     
  178.     semInt->SetOSLSupportFlags(ev, fOSLFlags);
  179.     semInt->UsingPredispatchProc(ev, fUsingPredispatchProc);
  180.     
  181.     return semInt;
  182. }
  183.  
  184. //---------------------------------------------------------------------------------------
  185. //    FW_CSemanticInterface::AcquireSOMInterface
  186. //---------------------------------------------------------------------------------------
  187.  
  188. FW_OSemanticInterface* FW_CSemanticInterface::AcquireSOMInterface(Environment* ev)
  189. {
  190.     return (FW_OSemanticInterface*)fPart->GetExtensionManager(ev)->AcquireExtension(ev, kODExtSemanticInterface, FW_kDontCreateExtension);
  191. }
  192.  
  193. //========================================================================================
  194. //  Begin Callbacks
  195. //========================================================================================
  196.  
  197. //---------------------------------------------------------------------------------------
  198. //    FW_CSemanticInterface::CallEventHandler
  199. //---------------------------------------------------------------------------------------
  200.  
  201. void FW_CSemanticInterface::CallEventHandler(Environment* ev, 
  202.                                             FW_CAppleEvent& event, 
  203.                                             FW_CAppleEvent& reply)
  204. {
  205.     // FW_DebugIdentifyPart(ev, fPart->GetLastActiveFrame(ev), FW_kRGBGreen);
  206.     
  207.     FW_CAcquiredScriptable targetObject = AcquireTargetObject(ev, event);
  208.  
  209.     AEKeyword eventClass = event.GetEventClass();
  210.     AEKeyword eventID = event.GetEventID();
  211.         
  212.     targetObject->HandleSemanticEvent(ev, fPart, eventClass, eventID, event, reply);
  213. }
  214.     
  215. //---------------------------------------------------------------------------------------
  216. //    FW_CSemanticInterface::CallCoercionHandler
  217. //---------------------------------------------------------------------------------------
  218.  
  219. void FW_CSemanticInterface::CallCoercionHandler(Environment* ev,
  220.                                                 const FW_CDesc& theDesc,
  221.                                                 ODDescType toType,
  222.                                                 FW_CDesc& theResult)
  223. {
  224. FW_UNUSED(ev);
  225.     FW_Handled handled = FW_CDescCoercionCallbacks::InvokeHandler(theDesc, toType, theResult);
  226.     if (handled == FW_kNotHandled)
  227.         FW_Failure(errAECoercionFail);
  228. }
  229.                                             
  230. //---------------------------------------------------------------------------------------
  231. //    FW_CSemanticInterface::CallPredispatchProc
  232. //---------------------------------------------------------------------------------------
  233.  
  234. void FW_CSemanticInterface::CallPredispatchProc(Environment* ev, 
  235.                                                 FW_CAppleEvent& event,
  236.                                                 FW_CAppleEvent& reply)
  237. {
  238. FW_UNUSED(ev);
  239. FW_UNUSED(event);
  240. FW_UNUSED(reply);
  241.     FW_Failure(errAEEventNotHandled);
  242. }
  243.  
  244. //---------------------------------------------------------------------------------------
  245. //    FW_CSemanticInterface::CallObjectAccessor
  246. //---------------------------------------------------------------------------------------
  247.  
  248. void FW_CSemanticInterface::CallObjectAccessor(Environment* ev,
  249.                                                 ODDescType desiredClass,
  250.                                                 ODOSLToken* container,
  251.                                                 ODDescType containerClass,
  252.                                                 ODDescType form,
  253.                                                 FW_CDesc& selectionData,
  254.                                                 ODOSLToken* value)
  255. {
  256.     // FW_DebugIdentifyPart(ev, fPart->GetLastActiveFrame(ev), FW_kRGBBlue);
  257.     
  258.     FW_CDesc containedObjectToken(GetDescFromToken(ev, value));
  259.     FW_CDesc containerToken(GetDescFromToken(ev, container));
  260.     FW_CAcquiredScriptable acquiredObject;
  261.     
  262.             // OpenDoc 1.0 doesn't handle OSLSupportFlags correctly.
  263.             // Instead of respecting our request for object marking,
  264.             // we get a container token here that is a list built
  265.             // by the OD OSL. For now, we'll simulate marking by
  266.             // building generating a collection of marked objects ourselves.
  267.             
  268.     if (containerToken.IsList() && desiredClass == cProperty)
  269.     {
  270.         ODDescType whichProperty;
  271.         
  272.         selectionData >> whichProperty;
  273.         acquiredObject = CreateCollectionFromList(ev, fPart, containerToken, whichProperty);
  274.     }
  275.     else
  276.     {
  277.         if (containerClass == cPart)
  278.         {
  279.             FW_MPartScriptable* part = GetDefaultContainer();
  280.             acquiredObject = part->AcquireObjectContainedInPart(ev, desiredClass, form, selectionData);
  281.         }
  282.         else
  283.         {
  284.             FW_MScriptable* containerObject;
  285.             
  286.             if (containerToken.IsNullDescriptor())
  287.                 containerObject = GetDefaultContainer();
  288.             else
  289.                 containerObject = ::FW_ExtractScriptableFromDesc(containerToken);
  290.         
  291.             acquiredObject = containerObject->AcquireContainedObject(ev, fPart, desiredClass, form, selectionData);
  292.         }
  293.         
  294.     }
  295.     
  296.     if (acquiredObject != NULL)
  297.         ::FW_InsertScriptableIntoDesc(acquiredObject, containedObjectToken);
  298.     else
  299.         FW_Failure(errAEEventNotHandled);
  300. }
  301.                                                     
  302. //---------------------------------------------------------------------------------------
  303. //    FW_CSemanticInterface::CallCompareProc
  304. //---------------------------------------------------------------------------------------
  305.  
  306. void FW_CSemanticInterface::CallCompareProc(Environment* ev,
  307.                                             ODDescType oper,
  308.                                             ODOSLToken* obj1,
  309.                                             ODOSLToken* obj2,
  310.                                             ODBoolean* result)
  311. {
  312.     FW_CDesc desc1(GetDescFromToken(ev, obj1));
  313.     FW_CDesc desc2(GetDescFromToken(ev, obj2));
  314.         
  315.     if (desc1.DescriptorType() == FW_kSemanticObjectTokenType)
  316.     {
  317.         FW_MScriptable* semanticObject = ::FW_ExtractScriptableFromDesc(desc1);
  318.         *result = semanticObject->CompareScriptableObjects(ev, fPart, oper, desc2);
  319.     }
  320.     else
  321.         FW_Failure(errAEEventNotHandled);
  322. }
  323.                                                     
  324. //---------------------------------------------------------------------------------------
  325. //    FW_CSemanticInterface::CallCountProc
  326. //---------------------------------------------------------------------------------------
  327. void FW_CSemanticInterface::CallCountProc(Environment* ev,
  328.                                         ODDescType desiredClass,
  329.                                         ODDescType containerClass,
  330.                                         ODOSLToken* container,
  331.                                         ODSLong* result)
  332. {
  333.     FW_CDesc containerToken(GetDescFromToken(ev, container));
  334.     
  335.     long                elementCount = 0;
  336.  
  337.     if (containerClass == cPart)
  338.     {
  339.         elementCount = GetDefaultContainer()->CountElementsInPart(ev, desiredClass);
  340.     }
  341.     else
  342.     {
  343.         FW_MScriptable*    containerObject = NULL;
  344.  
  345.         if (containerToken.IsNullDescriptor())
  346.             containerObject = GetDefaultContainer();
  347.         else
  348.             containerObject = ::FW_ExtractScriptableFromDesc(containerToken);
  349.         
  350.         elementCount = containerObject->CountElements(ev, fPart, desiredClass);
  351.     }
  352.     
  353.     *result = elementCount;
  354. }
  355.  
  356. //---------------------------------------------------------------------------------------
  357. //    FW_CSemanticInterface::CallDisposeTokenProc
  358. //---------------------------------------------------------------------------------------
  359. void FW_CSemanticInterface::CallDisposeTokenProc(Environment* ev, ODOSLToken* unneededToken)
  360. {
  361.     FW_CDesc token(GetDescFromToken(ev, unneededToken));
  362.     
  363.     if (token.DescriptorType() == FW_kSemanticObjectTokenType)
  364.     {
  365.         FW_MScriptable* scriptableObject = ::FW_ExtractScriptableFromDesc(token);
  366.         scriptableObject->ReleaseScriptable();
  367.         token.Clear();
  368.     }
  369.     else
  370.         FW_Failure(errAEEventNotHandled);
  371. }
  372.                                                         
  373. //---------------------------------------------------------------------------------------
  374. //    FW_CSemanticInterface::CallGetErrDescProc
  375. //---------------------------------------------------------------------------------------
  376. void FW_CSemanticInterface::CallGetErrDescProc(Environment* ev, ODDesc** errDesc)
  377. {
  378. FW_UNUSED(ev);
  379. FW_UNUSED(errDesc);
  380.     FW_Failure(errAEEventNotHandled);
  381. }
  382.                                                     
  383. //---------------------------------------------------------------------------------------
  384. //    FW_CSemanticInterface::CallGetMarkTokenProc
  385. //---------------------------------------------------------------------------------------
  386. void FW_CSemanticInterface::CallGetMarkTokenProc(Environment* ev,
  387.                                                 ODOSLToken* dContainerToken,
  388.                                                 ODDescType    containerClass,
  389.                                                 ODOSLToken* result)
  390. {
  391. FW_UNUSED(dContainerToken);
  392. FW_UNUSED(containerClass);
  393.     
  394.     // FW_DebugIdentifyPart(ev, fPart->GetLastActiveFrame(ev), FW_kRGBBlue);
  395.     
  396.     FW_CDesc collectionToken(GetDescFromToken(ev, result));
  397.  
  398.     FW_CAcquiredScriptable collection = FW_NEW(FW_CScriptableCollection, ());
  399.     ::FW_InsertScriptableIntoDesc(collection, collectionToken);
  400. }
  401.                                                         
  402. //---------------------------------------------------------------------------------------
  403. //    FW_CSemanticInterface::CallMarkProc
  404. //---------------------------------------------------------------------------------------
  405. void FW_CSemanticInterface::CallMarkProc(Environment* ev,
  406.                                         ODOSLToken* objectToMarkToken,
  407.                                         ODOSLToken* markingListToken,
  408.                                         ODSLong index)
  409. {
  410. FW_UNUSED(index);
  411.  
  412.     // FW_DebugIdentifyPart(ev, fPart->GetLastActiveFrame(ev), FW_kRGBRed);
  413.     
  414.     FW_CDesc objectToMarkDesc(GetDescFromToken(ev, objectToMarkToken));
  415.     FW_CDesc markingListDesc(GetDescFromToken(ev, markingListToken));
  416.     
  417.     FW_MScriptable* objectToMark = ::FW_ExtractScriptableFromDesc(objectToMarkDesc);
  418.     FW_CScriptableCollection* collection = 
  419.         FW_DYNAMIC_CAST(FW_CScriptableCollection, ::FW_ExtractScriptableFromDesc(markingListDesc));
  420.     
  421.     collection->Add(objectToMark);
  422. }
  423.     
  424. //---------------------------------------------------------------------------------------
  425. //    FW_CSemanticInterface::CallAdjustMarksProc
  426. //---------------------------------------------------------------------------------------
  427. void FW_CSemanticInterface::CallAdjustMarksProc(Environment* ev,
  428.                                                 ODSLong newStart,
  429.                                                 ODSLong newStop,
  430.                                                 ODOSLToken* markToken)
  431. {
  432.     // FW_DebugIdentifyPart(ev, fPart->GetLastActiveFrame(ev), FW_kRGBGreen);
  433.     
  434.     FW_CDesc markingListDesc(GetDescFromToken(ev, markToken));
  435.     FW_CScriptableCollection* collection = 
  436.         FW_DYNAMIC_CAST(FW_CScriptableCollection, ::FW_ExtractScriptableFromDesc(markingListDesc));
  437.     
  438.     collection->AdjustMarks(ev, newStart, newStop);
  439. }
  440.     
  441. //---------------------------------------------------------------------------------------
  442. //    FW_CSemanticInterface::GetOSLSupportFlags
  443. //---------------------------------------------------------------------------------------
  444.  
  445. ODSShort FW_CSemanticInterface::GetOSLSupportFlags(Environment* ev)
  446. {
  447. FW_UNUSED(ev);
  448.     return fOSLFlags;
  449. } 
  450.  
  451. //---------------------------------------------------------------------------------------
  452. //    FW_CSemanticInterface::SetOSLSupportFlags
  453. //---------------------------------------------------------------------------------------
  454.  
  455. void FW_CSemanticInterface::SetOSLSupportFlags(Environment* ev, ODSShort flags)
  456. {
  457.     fOSLFlags = flags;
  458.     
  459.     FW_OSemanticInterface* semInt = AcquireSOMInterface(ev);
  460.     if (semInt)
  461.     {
  462.         semInt->SetOSLSupportFlags(ev, flags);
  463.         semInt->Release(ev);
  464.     }
  465. }
  466.                                                     
  467. //---------------------------------------------------------------------------------------
  468. //    FW_CSemanticInterface::UsingPredispatchProc
  469. //---------------------------------------------------------------------------------------
  470.  
  471. void FW_CSemanticInterface::UsingPredispatchProc(Environment* ev, ODBoolean usingNotUsing)
  472. {
  473.     fUsingPredispatchProc = usingNotUsing;
  474.     
  475.     ODSemanticInterface* semInt = AcquireSOMInterface(ev);
  476.     if (semInt)
  477.     {
  478.         semInt->UsingPredispatchProc(ev, usingNotUsing);
  479.         semInt->Release(ev);
  480.     }
  481. }
  482.  
  483. //---------------------------------------------------------------------------------------
  484. //    FW_CSemanticInterface::CreateCollectionFromList
  485. //---------------------------------------------------------------------------------------
  486.  
  487. FW_MScriptable* FW_CSemanticInterface::CreateCollectionFromList(Environment* ev,
  488.                                                                     FW_CPart* part,
  489.                                                                     const FW_CDesc& objectList,
  490.                                                                     ODDescType whichProperty) const
  491. {
  492.     FW_ASSERT(objectList.IsList());
  493.     
  494.     // FW_DebugIdentifyPart(ev, fPart->GetLastActiveFrame(ev), FW_kRGBPurple);
  495.     
  496.     FW_CScriptableCollection* collection = FW_NEW(FW_CScriptableCollection, ());
  497.     
  498.     FW_CDesc     currentODToken;
  499.     FW_CDesc    currentToken;
  500.     long         itemsInList = objectList.GetItemCount();
  501.     
  502.     for (long index = 1; index <= itemsInList; index++)
  503.     {
  504.         currentODToken.Clear();
  505.         currentToken.Clear();
  506.         
  507.         objectList.GetDescFromList(index, currentODToken);
  508.         currentToken = GetDescFromToken(ev, currentODToken);
  509.         
  510.         FW_MScriptable* semObj = ::FW_ExtractScriptableFromDesc(currentToken);
  511.         
  512.         if (whichProperty != keyNoKey)
  513.         {
  514.             FW_CPropertyDesignator* propDesignator;
  515.  
  516.             propDesignator = FW_NEW(FW_CPropertyDesignator, (part, semObj, whichProperty));
  517.             collection->Add(propDesignator);
  518.         }
  519.         else
  520.             collection->Add(semObj);
  521.     }
  522.     return collection;
  523. }
  524.  
  525. //---------------------------------------------------------------------------------------
  526. //    FW_CSemanticInterface::GetDescFromToken
  527. //---------------------------------------------------------------------------------------
  528.  
  529. ODDesc* FW_CSemanticInterface::GetDescFromToken(Environment* ev, 
  530.                                                 ODOSLToken* token) const
  531. {
  532.     ODNameResolver* nameResolver = FW_CSession::GetNameResolver(ev);
  533.     return (nameResolver->IsODToken(ev, token) ? nameResolver->GetUserToken(ev, token) : token);
  534. }
  535.  
  536. //---------------------------------------------------------------------------------------
  537. //    FW_CSemanticInterface::AcquireTargetObject
  538. //---------------------------------------------------------------------------------------
  539.  
  540. FW_MScriptable* FW_CSemanticInterface::AcquireTargetObject(Environment* ev,
  541.                                                     FW_CAppleEvent& event)
  542. {
  543.     FW_CDesc targetObjectDesc;
  544.     FW_MScriptable* result = NULL;
  545.     
  546.     if (event.HasDataKey(keyDirectObject))
  547.     {
  548.         FW_CDesc directObjectToken;
  549.         
  550.         event.GetDataByDesc(directObjectToken, keyDirectObject);
  551.         result = AcquireScriptableFromToken(ev, directObjectToken);
  552.     }
  553.     else if (event.HasAttribute(keySubjectAttr))
  554.     {
  555.         FW_CDesc subjectDesc;
  556.         event.GetSubject(subjectDesc);
  557.         Resolve(ev, subjectDesc, targetObjectDesc);
  558.         
  559.         FW_TRY
  560.         {
  561.             result = AcquireScriptableFromToken(ev, targetObjectDesc);
  562.         }
  563.         FW_CATCH_BEGIN
  564.         FW_CATCH_EVERYTHING()
  565.         {
  566.             FW_CSession::GetNameResolver(ev)->DisposeToken(ev, targetObjectDesc);
  567.             FW_THROW_SAME();
  568.         }
  569.         FW_CATCH_END
  570.         
  571.         FW_CSession::GetNameResolver(ev)->DisposeToken(ev, targetObjectDesc);
  572.     }
  573.     else
  574.         FW_Failure(errAEEventNotHandled);
  575.     
  576.     return result;
  577. }
  578.  
  579. //---------------------------------------------------------------------------------------
  580. //    FW_CSemanticInterface::Resolve
  581. //---------------------------------------------------------------------------------------
  582.  
  583. void FW_CSemanticInterface::Resolve(Environment* ev,
  584.                                     const FW_CDesc& objectSpec,
  585.                                     FW_CDesc& odfToken,
  586.                                     ODPart* contextPart) const
  587. {
  588.     if (objectSpec.IsNullDescriptor())
  589.     {
  590.         odfToken.Clear();
  591.     }
  592.     else
  593.     {    
  594.         ODNameResolver* nameResolver = FW_CSession::GetNameResolver(ev);
  595.         
  596.         nameResolver->Resolve(ev, objectSpec, odfToken, contextPart);
  597.         odfToken.SetOwnsODData(FALSE);
  598.     }
  599. }
  600.  
  601. //---------------------------------------------------------------------------------------
  602. //    FW_CSemanticInterface::AcquireScriptableFromToken
  603. //---------------------------------------------------------------------------------------
  604.  
  605. FW_MScriptable* FW_CSemanticInterface::AcquireScriptableFromToken(Environment* ev,
  606.                                                                 const FW_CDesc& odToken) const
  607. {    
  608.     FW_MScriptable* scriptable = NULL;
  609.     FW_CDesc        odfToken = GetDescFromToken(ev, odToken);
  610.     ODDescType        tokenType = odfToken.DescriptorType();
  611.     FW_Boolean        contextIsMyPart = false;
  612.  
  613.         // The tokenType == kODStandardPartTokenType is necessary to work around
  614.         // two bugs in OpenDoc 1.1 and earlier (possibly later) releases. When
  615.         // an apple event without a direct object is received by OpenDoc, the subject
  616.         // attribute is resolved, and the event is dispatched based on the resolved
  617.         // subject attribute. Because of a bug in OpenDoc, the event might first
  618.         // be dispatched to the wrong part - sometimes the root, sometimes the
  619.         // part that contains the actual target. Whether it goes to the root or
  620.         // the containing part is a function of the specifier form used.
  621.         // The code below attempts to detect the case where an event has been
  622.         // mis-dispatched. We look for a standard ODPartToken and, if we find
  623.         // one, we call GetContextFromToke.
  624.         // There is a second bug in OpenDoc that causes the context to usually
  625.         // be wrong. Consequently, we can't really work around the first bug.
  626.         // When the contextPart is NULL, this is an indication that the event
  627.         // was first misdispatched to the shell, and is now being dispatched
  628.         // to us. We treat this as an event targeted at the part. When the
  629.         // contextPart is not NULL, we compare it against our part. Because of
  630.         // the first bug, contextPart will usually be our container when it
  631.         // should be us...we can't reliably detect this case, so we treat it
  632.         // as if it's not our event (we might actually be the container getting
  633.         // the event that is really targeted at something we contain).
  634.         
  635.         // What this means: Events without direct objects do not work and are
  636.         // not reliable in the current version of OpenDoc. Sometimes they will
  637.         // make it into the part and get handled, sometimes they won't.
  638.     if (tokenType == kODStandardPartTokenType)
  639.     {
  640.         ODPart* contextPart;
  641.         ODFrame* contextFrame;
  642.         FW_CSession::GetNameResolver(ev)->GetContextFromToken(ev, odToken, &contextPart, &contextFrame);
  643.         
  644.         if (!contextPart || (contextPart == fPart->GetODPart(ev)))
  645.             contextIsMyPart = true;
  646.     }
  647.     
  648.     if (odfToken.IsNullDescriptor() || contextIsMyPart)
  649.     {
  650.         scriptable = GetDefaultContainer();
  651.         scriptable->AcquireScriptable();
  652.     }
  653.     else if (tokenType == FW_kSemanticObjectTokenType)
  654.     {
  655.         scriptable = ::FW_ExtractScriptableFromDesc(odfToken);
  656.         scriptable->AcquireScriptable();
  657.     }
  658.     else if (odfToken.IsList())
  659.     {
  660.         scriptable = CreateCollectionFromList(ev, fPart, odfToken);
  661.     }
  662.     else
  663.         FW_Failure(errAEEventNotHandled);
  664.         
  665.     return scriptable;
  666. }
  667.  
  668. //---------------------------------------------------------------------------------------
  669. //    FW_DebugIdentifyPart:
  670. //    This utility method is for debugging semantic event handling in nested parts.
  671. //    A circle of the specified color will be briefly displayed in the top left
  672. //    corner of the first facet of the specified frame. This method does not attempt 
  673. //  to redraw or invalidate the content area obscured by the circle.
  674. //
  675. //    Note: This method may not be a permanent part of the ODF API.
  676. //---------------------------------------------------------------------------------------
  677.  
  678. void FW_DebugIdentifyPart(Environment* ev, FW_CFrame* frame, const FW_CColor& color)
  679. {
  680.     if (frame)
  681.     {
  682.         FW_CFrameFacetIterator iter(ev, frame);
  683.         FW_CViewContext vc(ev, frame, iter.First(ev), NULL);
  684.         FW_CRect rect(FW_kFixed0, FW_kFixed0, FW_IntToFixed(10), FW_IntToFixed(10));
  685.         
  686.         FW_CInk ink;
  687.         ink.SetForeColor(color);
  688.         ink.SetTransferMode(FW_kCopy);
  689.         FW_COvalShape::RenderOval(vc, rect, FW_kFill, ink);
  690.         FW_WaitFor(20);
  691.         ink.SetTransferMode(FW_kErase);
  692.         FW_COvalShape::RenderOval(vc, rect, FW_kFill, ink);
  693.     }
  694. }
  695.                                                     
  696. //========================================================================================
  697. //  End Callbacks
  698. //========================================================================================
  699.  
  700. //---------------------------------------------------------------------------------------
  701. //    FW_CSemanticInterface::PrivCreate
  702. //---------------------------------------------------------------------------------------
  703.  
  704. ODExtension* FW_CSemanticInterface::PrivCreate(Environment* ev, FW_CPart* part, const char* name, void* refCon)
  705. {
  706.     return (part->GetSemanticInterface(ev)->CreateSOMInterface(ev, part, name, refCon));        
  707. }
  708.